import java.util.Scanner;

public class Test {


    //小葱的01串
    //滑动窗口
    //链接：https://ac.nowcoder.com/acm/problem/230830
    //来源：牛客网
    //
    //给定一个长度为偶数的环形 01 字符串。（环形指，第一个字符和最后一个字符是相邻的）
    //字符串初始每个字符都是白色。小葱想把一段连续区间染成红色，使得红色的字符'0'数量等于白色的字符'0'数量，
    // 红色的字符'1'数量等于白色的字符'1'数量。问有多少种不同的染色方法？
    //两个方案不同当且仅当存在一个某字符，在一个方案是染成红色，在另一个方案为白色。
    //输入描述:
    //第一行输入一个正整数n，代表字符串长度。
    //第二行输入一个长度为n 的 01 字符串（仅由字符'0'和字符'1'组成的字符串）
    //数据范围：2≤n≤300000 。保证n 是偶数。
    //输出描述:
    //合法的染色方案数。
    //示例1
    //输入
    //2
    //11
    //输出
    //2
    //说明
    //将第一个数字染红为一个方案。
    //将第二个数字染红为一个方案。
    //示例2
    //输入
    //4
    //0101
    //输出
    //4
    //说明
    //任意一个长度为2的区间染红均合法。
    //示例3
    //输入
    //4
    //1100
    //输出
    //2
    //说明
    //可以将区间 [2,3] 染红，或者将第一个和最后一个字符染红（因为是个环，所以第一个和最后一个也是相邻区间）。
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        char[] s = in.next().toCharArray();
        int[] sum = new int[2];
        for (int i = 0; i < n; i++) {
            sum[s[i]-'0']++;
        }
        int left = 0,right = 0,ret = 0,half = n/2;
        int[] count = new int[2];
        while (right<n-1){
            count[s[right]-'0']++;
            while(right-left+1>half){
                count[s[left++]-'0']--;
            }
            if(right-left+1 == half){
                if(count[0] *2 == sum[0] && count[1]*2 == sum[1]){
                    ret+=2;
                }
            }
            right++;
        }
        System.out.println(ret);
    }




    //最大的矩阵（二维前缀和）
    //算法思路：
    //⼆维前缀和矩阵的应⽤。
    //a. 初始化⼆维前缀和矩阵；
    //b. 枚举所有的⼦矩阵，求出最⼤⼦矩阵。
    //描述
    //已知矩阵的大小定义为矩阵中所有元素的和。给定一个矩阵，你的任务是找到最大的非空(大小至少是1 * 1)子矩阵。
    // 比如，如下4 * 4的矩阵 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 的最大子矩阵是
    // 9 2 -4 1 -1 8 这个子矩阵的大小是15。
    //输入描述：
    //输入是一个N * N的矩阵。输入的第一行给出N (0 < N <= 100)。 再后面的若干行中，
    // 依次（首先从左到右给出第一行的N个整数，再从左到右给出第二行的N个整数……）给出矩阵中的N2个整数，
    // 整数之间由空白字符分隔（空格或者空行）。 已知矩阵中整数的范围都在[-127, 127]。
    //输出描述：
    //输出最大子矩阵的大小。
    //示例1
    //输入：
    //4
    //0 -2 -7 0
    //9 2 -6 2
    //-4 1 -4  1
    //-1 8  0 -2
    //输出：
    //15
    public static int n;
    public static int[][] dp = new int[110][110];

    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                int x = in.nextInt();
                dp[i][j] = dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]+x;
            }
        }

        int ret = -127;
        for(int x1 = 1;x1<=n;x1++){
            for(int y1 =1;y1<=n;y1++){
                for(int x2 = x1;x2<=n;x2++){
                    for(int y2  =y1;y2<=n;y2++){
                        ret = Math.max(ret,dp[x2][y2]-dp[x1-1][y2]-dp[x2][y1-1]+dp[x1-1][y1-1]);
                    }
                }
            }
        }
        System.out.println(ret);
    }






    //判断是不是平衡二叉树（二叉树+递归）
    //输入一棵节点数为 n 二叉树，判断该二叉树是否是平衡二叉树。
    //在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树
    //平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，
    // 并且左右两个子树都是一棵平衡二叉树。
    //样例解释：
    //样例二叉树如图，为一颗平衡二叉树
    //注：我们约定空树是平衡二叉树。
    //数据范围：n≤100,树上节点的val值满足0≤n≤1000
    //要求：空间复杂度O(1)，时间复杂度O(n)
    //输入描述：
    //输入一棵二叉树的根节点
    //返回值描述：
    //输出一个布尔类型的值
    //示例1
    //输入：
    //{1,2,3,4,5,6,7}
    //返回值：
    //true
    //示例2
    //输入：
    //{}
    //返回值：
    //true
    //算法思路：
    //递归即可。
    //利⽤返回值，判断左右⼦树的⾼度和左右⼦树是否是平衡⼆叉树。
     public class TreeNode {
       int val = 0;
        TreeNode left = null;
       TreeNode right = null;
       public TreeNode(int val) {
         this.val = val;
       }
     }


    public boolean IsBalanced_Solution (TreeNode pRoot) {
        return dfs(pRoot)!= -1;
    }

    public int dfs(TreeNode root){
         if(root == null){
             return 0;
         }
         int left = dfs(root.left);
         if(left == -1){
             return -1;
         }
         int right = dfs(root.right);
         if (right == -1){
             return -1;
         }
         return Math.abs(left - right) <= 1 ? Math.max(left,right) +1 : -1;

    }


}
